package com.xiechuang.helper;

import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * @Description: 校验助手
 * @Author: xiechuang
 * @Date: 2023/1/11
 */
public class ValidHelper implements Serializable {

    public static Boolean isNull(Object object) {
        return object == null;
    }

    public static Boolean isNotNull(Object object) {
        return object != null;
    }

    public static Boolean isEmpty(Integer number) {
        return (isNull(number) || number == 0 || number < 1);
    }

    public static Boolean isEmpty(Long number) {
        return (isNull(number) || number == 0 || number < 1);
    }

    public static Boolean isEmpty(String string) {
        return (isNull(string) || string.trim().length() == 0);
    }

    public static Boolean isEmpty(List list) {
        return (isNull(list) || list.size() < 1);
    }

    public static Boolean isEmpty(Object[] objects) {
        return (isNull(objects) || objects.length < 1);
    }

    public static Boolean isEmpty(Collection objects) {
        return (isNull(objects) || objects.isEmpty() || (objects.size() == 1 && objects.iterator().next() == null));
    }

    public static Boolean isEmpty(Object object, String... equals) {
        if (isNull(object)) {
            return true;
        } else if (object instanceof String) {
            if (isEmpty((String) object)) {
                return true;
            }
            if (equals.length == 0) {
                return false;
            }
            for (String equal : equals) {
                if (StringUtils.equalsIgnoreCase((String) object, equal)) {
                    return true;
                }
            }
            return false;
        } else if (object instanceof Long) {
            return isEmpty((Long) object);
        } else if (object instanceof Collection) {
            return isEmpty((Collection) object);
        } else if (object instanceof Integer) {
            return isEmpty((Integer) object);
        } else if (object instanceof Object[]) {
            return isEmpty((Object[]) object);
        } else if (object instanceof Map) {
            return ((Map) object).isEmpty();
        }
        if (equals.length == 0) {
            return false;
        } else {
            for (String equal : equals) {
                if (StringUtils.equalsIgnoreCase(object.toString(), equal)) {
                    return true;
                }
            }
        }
        return false;
    }


    public static Boolean isNotEmpty(Object object) {
        return !isEmpty(object);
    }

    /**
     * <b>功能：</b>验证字符串str是否只包含英文,数字和"-_"
     *
     * @param str 待验证字符串
     * @return true    是只包含英文,数字和"-_" false	不是只包含英文,数字和"-_"
     */
    public static boolean onlyCharAndNumber(String str) {
        return RegexHelper.onlyCharAndNumberRegex.matcher(str).find();
    }


    /**
     * <b>功能：</b>验证字符串str是否只包含英文,数字,中文,空格和"-_"
     *
     * @param str 待验证字符串
     * @return true    是只包含英文,数字,中文和"-_" false	不是只包含英文,数字,中文和"-_"
     */
    public static boolean onlyCharAndNumberAndCh(String str) {
        return RegexHelper.onlyCharAndNumberAndChRegex.matcher(str).find();
    }

    /**
     * 只包含字母
     *
     * @param str
     * @return
     */
    public static boolean onlyLetter(String str) {
        return RegexHelper.onlyLetterRegex.matcher(str).find();
    }


    /**
     * <b>功能：</b>验证字符串email是否符合email格式
     *
     * @param email 待验证邮件地址
     * @return true    符合 false	不符合
     */
    public static boolean isEmail(String email) {
        return !isEmpty(email) && RegexHelper.emailRegex.matcher(email).find();
    }

    /**
     * <b>功能：</b>验证字符串url是否符合url格式
     *
     * @param url 待验证URL地址
     * @return true    符合 false	不符合
     */
    public static boolean isUrl(String url) {
        return !isEmpty(url) && RegexHelper.urlRegex.matcher(url).find();
    }


    /**
     * <b>功能：</b>验证字串是否手机号
     *
     * @param mobile 待验证手机号
     * @return true    符合 false	不符合
     */
    public static boolean isMobile(String mobile) {
        return !isEmpty(mobile) && RegexHelper.mobileRegex.matcher(mobile).find();
    }

    /**
     * <b>功能：</b>验证字串图片文件是否属于限定的某中类型格式
     *
     * @param filepath 待验证图片名称
     * @return true    符合 false	不符合
     */
    public static boolean isImageFile(String filepath) {
        return !isEmpty(filepath) && RegexHelper.imagePostfixRegex.matcher(filepath).find();
    }


    /**
     * <b>功能：</b>验证字符串date是否符合Date格式
     *
     * @param date 待验证日期
     * @return true    符合 false	不符合
     */
    public static boolean isDate(Object date) {
        if (date instanceof Date) {
            return true;
        }
        return !isEmpty(date) && (RegexHelper.dateRegex.matcher(date.toString()).find() || RegexHelper.numberDateRegex.matcher(date.toString()).find());
    }

    public static boolean isNumber(String number) {
        return !isEmpty(number) && RegexHelper.numberRegex.matcher(number).find();
    }

    /**
     * <b>功能：</b>验证字符串tags是否符合 Tags标签 正确格式 (aaa ddd ccc)
     *
     * @param tags
     * @return true|false 符合标签格式 true 否则false
     */
    public static boolean tags(String tags) {
        return !isEmpty(tags) && RegexHelper.tagRegex.matcher(tags).find();
    }

    /**
     * <b>功能：</b>查找字符串email的邮箱名称
     *
     * @param email
     * @return 邮箱 用户名
     */
    public static String findEmailName(String email) {
        return isEmpty(email) || email.indexOf("@") == -1 ? "" : email.substring(0, email.indexOf("@"));
    }

    /**
     * 正则验证
     *
     * @param value
     * @param regex
     * @return
     */
    public static boolean matches(Object value, String regex) {
        return !(isEmpty(value) || isEmpty(regex)) && String.valueOf(value).trim().matches(regex);
    }

    // 区间判断
    public static boolean isBetween(long value, long min, long end) {
        return value >= min && value <= end;
    }

    // 长度区间判断
    public static boolean isBetween(String value, int min, int max) {
        if (ValidHelper.isEmpty(value)) {
            return false;
        } else {
            return value.length() >= min || value.length() <= max;
        }
    }

    /**
     * 判断 长度是否在该区间内
     *
     * @param text
     * @param min
     * @param max
     * @return
     */
    public static boolean isLength(String text, int min, int max) {
        text = StringUtils.trim(text);
        return (text.length() <= max && text.length() >= min);
    }

    /**
     * 日期区间是否重叠
     *
     * @param leftStart
     * @param leftEnd
     * @param rightStart
     * @param rightEnd
     * @return
     */
    public static boolean isOverlap(Date leftStart, Date leftEnd, Date rightStart, Date rightEnd) {
        if (rightStart != null) {
            if (leftStart != null) {
                if (leftEnd != null) {
                    return null != leftStart && leftEnd != null && rightStart != null && rightEnd != null &&
                            (leftStart.getTime() >= rightStart.getTime() && leftStart.getTime() <= rightEnd.getTime()) ||
                            (rightStart.getTime() >= leftStart.getTime() && rightStart.getTime() <= leftEnd.getTime());
                }
            }
        }
        return false;
    }
}
